<html>
<head><meta charset="utf-8"><title>measuring parallel rustc · t-compiler · Zulip Chat Archive</title></head>
<h2>Stream: <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/index.html">t-compiler</a></h2>
<h3>Topic: <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html">measuring parallel rustc</a></h3>

<hr>

<base href="https://rust-lang.zulipchat.com">

<head><link href="https://rust-lang.github.io/zulip_archive/style.css" rel="stylesheet"></head>

<a name="165905953"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165905953" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165905953">(May 17 2019 at 14:45)</a>:</h4>
<p><span class="user-mention" data-user-id="116083">@pnkfelix</span> I don't quite understand what you mean by that, no</p>



<a name="165905964"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165905964" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165905964">(May 17 2019 at 14:45)</a>:</h4>
<p>so you have a nested for loop</p>



<a name="165905973"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165905973" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165905973">(May 17 2019 at 14:45)</a>:</h4>
<p>with N cases in the outer loop and M cases in the inner one</p>



<a name="165905976"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165905976" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165905976">(May 17 2019 at 14:45)</a>:</h4>
<p>and my immediate reaction was</p>



<a name="165906039"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906039" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906039">(May 17 2019 at 14:46)</a>:</h4>
<p>its not clear that we/you get much value in short term from exploring all those cases</p>



<a name="165906069"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906069" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906069">(May 17 2019 at 14:46)</a>:</h4>
<p>instead, might be better to loop over all N thread values while varying job among { j=1, j=2 }, for example</p>



<a name="165906078"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906078" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906078">(May 17 2019 at 14:46)</a>:</h4>
<p>ah, okay, yeah, that makes some sense</p>



<a name="165906105"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906105" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906105">(May 17 2019 at 14:47)</a>:</h4>
<p>I think I'm also not quite sure yet what the "correct" / "interesting" -j/-t arguments are</p>



<a name="165906106"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906106" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906106">(May 17 2019 at 14:47)</a>:</h4>
<p>and then loop over all M job values while varying thread count over the most important cases (which are probably { t=1, t=4 }, is my guess)</p>



<a name="165906125"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906125" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906125">(May 17 2019 at 14:47)</a>:</h4>
<p>yeah I agree its not clear what the interesting cases are</p>



<a name="165906133"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906133" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906133">(May 17 2019 at 14:47)</a>:</h4>
<p>but we can dive in gathering more data later</p>



<a name="165906152"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906152" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906152">(May 17 2019 at 14:47)</a>:</h4>
<p>I just don't want to swamp your machine time gathering lots of data for one crate</p>



<a name="165906156"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906156" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906156">(May 17 2019 at 14:47)</a>:</h4>
<p>I'm going to try to get full N x M data on Cargo with lower counts since that's pretty fast -- Cargo builds in a couple minutes</p>



<a name="165906164"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906164" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906164">(May 17 2019 at 14:47)</a>:</h4>
<p>when we want to spend less time and get data for more crates</p>



<a name="165906166"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906166" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> pnkfelix <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906166">(May 17 2019 at 14:48)</a>:</h4>
<p>okay, I can understand that.</p>



<a name="165906209"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906209" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906209">(May 17 2019 at 14:48)</a>:</h4>
<p>I think that should be done in an hour or so</p>



<a name="165906244"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906244" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906244">(May 17 2019 at 14:48)</a>:</h4>
<p>From there it seems viable that we'll/I'll be able to get  a better sense of interesting cases and switch to 2xN + 2xM or something like that</p>



<a name="165906637"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906637" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906637">(May 17 2019 at 14:54)</a>:</h4>
<p>I think <span class="user-mention" data-user-id="116122">@simulacrum</span> the high order bit is that the "order of exploration" matters -- we probably want "breadth-first" more than "depth-first"</p>



<a name="165906644"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906644" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906644">(May 17 2019 at 14:54)</a>:</h4>
<p>in other words, we'd rather see the "single thread overhead" and "two thread win" for all crates</p>



<a name="165906647"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906647" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906647">(May 17 2019 at 14:54)</a>:</h4>
<p>before seeing the "four thread win" for any crate</p>



<a name="165906648"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906648" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906648">(May 17 2019 at 14:54)</a>:</h4>
<p>at least that's my guess</p>



<a name="165906656"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906656" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906656">(May 17 2019 at 14:54)</a>:</h4>
<p>hm, that's a good point</p>



<a name="165906657"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906657" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906657">(May 17 2019 at 14:54)</a>:</h4>
<p>I feel like if we're regressing on 2 threads, that's a problem</p>



<a name="165906690"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906690" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906690">(May 17 2019 at 14:55)</a>:</h4>
<p>and <em>presumably</em> it'll only get better from there (...famous last words...)</p>



<a name="165906785"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906785" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906785">(May 17 2019 at 14:56)</a>:</h4>
<p>that would make sense</p>



<a name="165906810"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906810" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906810">(May 17 2019 at 14:56)</a>:</h4>
<p>So we're thinking maybe <code>-j{1,2,8,16}</code> and <code>-t{0,1,2}</code> where <code>-t0</code> is the single-threaded compiler?</p>



<a name="165906818"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906818" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906818">(May 17 2019 at 14:56)</a>:</h4>
<p>or even less data than that</p>



<a name="165906829"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906829" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906829">(May 17 2019 at 14:56)</a>:</h4>
<p>I could imagine not trying to optimize <code>-j</code> since presumably users won't set that</p>



<a name="165906863"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906863" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906863">(May 17 2019 at 14:57)</a>:</h4>
<p>i.e., just do <code>-j16</code> and <code>-t{0,1,2}</code></p>



<a name="165906917"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906917" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> mw <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906917">(May 17 2019 at 14:57)</a>:</h4>
<p>that sounds reasonable</p>



<a name="165906980"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906980" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906980">(May 17 2019 at 14:58)</a>:</h4>
<p><span class="user-mention" data-user-id="124287">@mw</span> which option -- the latter <code>-j16</code> or the first bit?</p>



<a name="165906989"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165906989" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> mw <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165906989">(May 17 2019 at 14:58)</a>:</h4>
<p>the latter</p>



<a name="165907005"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165907005" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> mw <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165907005">(May 17 2019 at 14:58)</a>:</h4>
<p><code>t &gt; j</code> never makes sense anyway, right?</p>



<a name="165907036"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165907036" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165907036">(May 17 2019 at 14:59)</a>:</h4>
<p>hm, presumably no</p>



<a name="165907039"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165907039" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Zoxc <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165907039">(May 17 2019 at 14:59)</a>:</h4>
<p>It does not</p>



<a name="165907054"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165907054" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> mw <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165907054">(May 17 2019 at 14:59)</a>:</h4>
<p>except for testing the jobserver :)</p>



<a name="165907092"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165907092" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165907092">(May 17 2019 at 14:59)</a>:</h4>
<p>okay, so the plan is ripgrep, servo, cranelift, maybe some more rustc measurements with <code>-j16</code> and varying <code>-t{0,1,2}</code> for now</p>



<a name="165907171"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165907171" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165907171">(May 17 2019 at 15:00)</a>:</h4>
<p><span class="user-mention" data-user-id="116083">@pnkfelix</span>  <span class="user-mention" data-user-id="116009">@nikomatsakis</span> does that sound to you? Should we add anything?</p>



<a name="165907528"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165907528" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165907528">(May 17 2019 at 15:04)</a>:</h4>
<p>And to what extent do we want -opt, -check, -debug runs?</p>



<a name="165907553"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165907553" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165907553">(May 17 2019 at 15:05)</a>:</h4>
<p>Currently I've just been doing -opt runs but those are both slower and maybe not as important?</p>



<a name="165907559"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165907559" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165907559">(May 17 2019 at 15:05)</a>:</h4>
<p>i.e., measuring LLVM to an extent</p>



<a name="165913370"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165913370" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165913370">(May 17 2019 at 16:10)</a>:</h4>
<p><span class="user-mention" data-user-id="116122">@simulacrum</span> that sounds good -- re: -opt, -check, and -debug, I think we definitely want more than just -opt -- but it's a good question. I guess I would prioritize doing;</p>
<ul>
<li>opt</li>
<li>debug</li>
<li>check</li>
</ul>
<p>in that order.</p>



<a name="165913382"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165913382" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165913382">(May 17 2019 at 16:10)</a>:</h4>
<p>Mostly because we know check is the best case</p>



<a name="165913393"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165913393" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165913393">(May 17 2019 at 16:10)</a>:</h4>
<p>Okay -- I'm putting data in <a href="https://docs.google.com/spreadsheets/d/1vadQWQQqTODU1_cAENnUjLyXM6cxms-tiCf2kCiNGGM/edit?usp=sharing" target="_blank" title="https://docs.google.com/spreadsheets/d/1vadQWQQqTODU1_cAENnUjLyXM6cxms-tiCf2kCiNGGM/edit?usp=sharing">https://docs.google.com/spreadsheets/d/1vadQWQQqTODU1_cAENnUjLyXM6cxms-tiCf2kCiNGGM/edit?usp=sharing</a></p>



<a name="165913415"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165913415" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165913415">(May 17 2019 at 16:11)</a>:</h4>
<p>I'm not actually sure if the order I wrote makes sense, I guess I could see an arugment for opt, check, debug</p>



<a name="165913423"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165913423" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165913423">(May 17 2019 at 16:11)</a>:</h4>
<p>worst, best, middle :)</p>



<a name="165913602"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165913602" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165913602">(May 17 2019 at 16:13)</a>:</h4>
<p>mhm, makes sense</p>



<a name="165913654"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165913654" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165913654">(May 17 2019 at 16:14)</a>:</h4>
<p>so far data collection is going fairly well</p>



<a name="165913691"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165913691" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165913691">(May 17 2019 at 16:15)</a>:</h4>
<p>I also have potentially interesting non-timing data as a side-effect of using perf to collect:</p>
<div class="codehilite"><pre><span></span>cargo-t1-check:
 Performance counter stats for &#39;cargo +6f087ac1c17723a84fd45f445c9887dbff61f8c0 check&#39; (2 runs):

     181022.616812      task-clock (msec)         #    4.248 CPUs utilized            ( +-  0.20% )
             17903      context-switches          #    0.099 K/sec                    ( +-  0.37% )
              4038      cpu-migrations            #    0.022 K/sec                    ( +-  0.35% )
           3348166      page-faults               #    0.018 M/sec                    ( +-  0.01% )
      669715893598      cycles                    #    3.700 GHz                      ( +-  0.19% )  (33.58%)
       87652401496      stalled-cycles-frontend   #   13.09% frontend cycles idle     ( +-  1.26% )  (33.51%)
       69564486867      stalled-cycles-backend    #   10.39% backend cycles idle      ( +-  0.33% )  (33.45%)
      595648635822      instructions              #    0.89  insn per cycle
                                                  #    0.15  stalled cycles per insn  ( +-  0.20% )  (33.38%)
      102489636524      branches                  #  566.170 M/sec                    ( +-  0.41% )  (33.27%)
        3548257867      branch-misses             #    3.46% of all branches          ( +-  0.14% )  (33.12%)
      315611174080      L1-dcache-loads           # 1743.490 M/sec                    ( +-  0.24% )  (33.05%)
         683586581      L1-dcache-load-misses     #    0.22% of all L1-dcache hits    ( +-  0.05% )  (33.05%)
                 0      LLC-loads                 #    0.000 K/sec                    (33.11%)
                 0      LLC-load-misses           #    0.00% of all LL-cache hits     (33.14%)
      145804411502      L1-icache-loads           #  805.449 M/sec                    ( +-  0.10% )  (33.20%)
       10244177108      L1-icache-load-misses                                         ( +-  0.49% )  (33.28%)
      312502970939      dTLB-loads                # 1726.320 M/sec                    ( +-  0.01% )  (33.37%)
         916415446      dTLB-load-misses          #    0.29% of all dTLB cache hits   ( +-  1.34% )  (33.44%)
      145367320817      iTLB-loads                #  803.034 M/sec                    ( +-  0.27% )  (33.45%)
         346043620      iTLB-load-misses          #    0.24% of all iTLB cache hits   ( +-  0.63% )  (33.48%)
           1437970      L1-dcache-prefetches      #    0.008 M/sec                    ( +-  0.02% )  (33.53%)
           3763609      L1-dcache-prefetch-misses #    0.021 M/sec                    ( +-  0.06% )  (33.61%)

      42.616428285 seconds time elapsed                                          ( +-  1.16% )
</pre></div>



<a name="165913707"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165913707" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165913707">(May 17 2019 at 16:15)</a>:</h4>
<p>but not sure if any of it is useful/helpful so going to leave it out of spreadsheet for now</p>



<a name="165931761"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165931761" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165931761">(May 17 2019 at 20:00)</a>:</h4>
<p><span class="user-mention" data-user-id="116015">@Alex Crichton</span> Do you have any insight into measuring jobserver "contention"? I'm interested in whether we can get better performance if we restrict rustcs invocations but still have all cores "available" to the internal threading within rustc</p>



<a name="165931800"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165931800" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165931800">(May 17 2019 at 20:01)</a>:</h4>
<p>basically say that only 4 rustcs processes should run at once but each can use up to 4 cores (since I have 16)</p>



<a name="165933135"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165933135" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Alex Crichton <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165933135">(May 17 2019 at 20:18)</a>:</h4>
<p><span class="user-mention" data-user-id="116122">@simulacrum</span> not currently, the protocol is basically an IPC semaphore which means there's not really any data other than "can I get something at this point" and "I can release something at this point</p>



<a name="165933143"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165933143" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Alex Crichton <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165933143">(May 17 2019 at 20:18)</a>:</h4>
<p>but no data on like "how many waiters are there"</p>



<a name="165933158"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165933158" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Alex Crichton <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165933158">(May 17 2019 at 20:19)</a>:</h4>
<p>we'd have to instrument rustc for more information like that (or make a better protocol)</p>



<a name="165933185"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165933185" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165933185">(May 17 2019 at 20:19)</a>:</h4>
<p>hm, okay -- I seemed to recall some graphs from you when we were just adding this but I guess I'm remembering the wrong thing or creating memories</p>



<a name="165933272"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165933272" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165933272">(May 17 2019 at 20:20)</a>:</h4>
<p>thanks!</p>



<a name="165937287"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165937287" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165937287">(May 17 2019 at 21:12)</a>:</h4>
<p><span class="user-mention" data-user-id="116009">@nikomatsakis</span> (and maybe others?) -- we have data for cargo, ripgrep, servo, and cranelift now (opt, debug, check, with -t{0,1,2} and -j16)</p>



<a name="165937290"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165937290" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165937290">(May 17 2019 at 21:12)</a>:</h4>
<p><a href="https://docs.google.com/spreadsheets/d/1vadQWQQqTODU1_cAENnUjLyXM6cxms-tiCf2kCiNGGM/edit#gid=0" target="_blank" title="https://docs.google.com/spreadsheets/d/1vadQWQQqTODU1_cAENnUjLyXM6cxms-tiCf2kCiNGGM/edit#gid=0">https://docs.google.com/spreadsheets/d/1vadQWQQqTODU1_cAENnUjLyXM6cxms-tiCf2kCiNGGM/edit#gid=0</a></p>



<a name="165937307"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165937307" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165937307">(May 17 2019 at 21:13)</a>:</h4>
<p>Overall -t2 is pretty much a win, if slight, across the board</p>



<a name="165937330"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165937330" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165937330">(May 17 2019 at 21:13)</a>:</h4>
<p>and -t1 is almost always a ~4% regression (ranging between ~1 second to 30 seconds at max)</p>



<a name="165937398"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165937398" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165937398">(May 17 2019 at 21:14)</a>:</h4>
<p>the 30 second case is possibly spurious but I've gotten pretty consistent measurements around that point after ~4 runs so probably not, even though it's odd how much it stands out</p>



<a name="165937409"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165937409" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165937409">(May 17 2019 at 21:14)</a>:</h4>
<p>it might point at some underlying problem that would be good to solve (cc <span class="user-mention" data-user-id="116466">@Zoxc</span> )</p>



<a name="165954949"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165954949" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165954949">(May 18 2019 at 03:15)</a>:</h4>
<p>Gathered data to build curves for essentially all meaningful values of -t while still keeping -j constant for Cargo</p>



<a name="165954950"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/165954950" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#165954950">(May 18 2019 at 03:15)</a>:</h4>
<p><a href="https://docs.google.com/spreadsheets/d/1vadQWQQqTODU1_cAENnUjLyXM6cxms-tiCf2kCiNGGM/edit#gid=1621301791&amp;range=A1" target="_blank" title="https://docs.google.com/spreadsheets/d/1vadQWQQqTODU1_cAENnUjLyXM6cxms-tiCf2kCiNGGM/edit#gid=1621301791&amp;range=A1">https://docs.google.com/spreadsheets/d/1vadQWQQqTODU1_cAENnUjLyXM6cxms-tiCf2kCiNGGM/edit#gid=1621301791&amp;range=A1</a></p>



<a name="166068613"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/166068613" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> mw <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#166068613">(May 20 2019 at 09:05)</a>:</h4>
<p>(I adapted the Y-axis in the charts to start at zero)</p>



<a name="167791141"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/167791141" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#167791141">(Jun 10 2019 at 19:59)</a>:</h4>
<p><span class="user-mention" data-user-id="116122">@simulacrum</span> thanks, those charts are super interesting. The data there is raw time values?</p>



<a name="167791974"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/167791974" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#167791974">(Jun 10 2019 at 20:08)</a>:</h4>
<p><span class="user-mention" data-user-id="116009">@nikomatsakis</span> Yes - in seconds.</p>



<a name="167792036"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/167792036" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#167792036">(Jun 10 2019 at 20:09)</a>:</h4>
<p>OK. It doesn't look too impressive, does it? :)</p>



<a name="167792115"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/167792115" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#167792115">(Jun 10 2019 at 20:10)</a>:</h4>
<p>But I guess these are the whole crate graph numbers, the "just tip crate" numbers look better</p>



<a name="167794874"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/167794874" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#167794874">(Jun 10 2019 at 20:45)</a>:</h4>
<p>Yes, indeed</p>



<a name="167794900"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/167794900" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#167794900">(Jun 10 2019 at 20:45)</a>:</h4>
<p><span class="user-mention" data-user-id="116009">@nikomatsakis</span> also, shaving 5-6 seconds off e.g. Cargo compilation isn't actually that bad</p>



<a name="167794962"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/measuring%20parallel%20rustc/near/167794962" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/measuring.20parallel.20rustc.html#167794962">(Jun 10 2019 at 20:46)</a>:</h4>
<p>plus this is presumably still with "single-threaded" looking code (i.e., we have some global locks that Zoxc mentioned a while back)</p>



<hr><p>Last updated: Aug 07 2021 at 22:04 UTC</p>
</html>